home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1994 November / macformat-018.iso / Utility Spectacular / Developer / halma-12-c / Halma ƒ / Shell ƒ / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-26  |  11.6 KB  |  462 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "menus.h"
  26. #include "help.h"
  27. #include "environment.h"
  28. #include "sounds.h"
  29. #include "error.h"
  30. #include "launch.h"
  31. #include "file interface.h"
  32. #include "halma load-save.h"
  33. #include "halma.h"
  34. #include "debinhex dispatch.h"
  35. #include "file management.h"
  36. #include "program globals.h"
  37. #include "halma snow.h"
  38.  
  39. extern    long        menuDisable : 0x0b54;
  40.  
  41. Boolean            gMenuEnabled;
  42. MenuHandle        gAppleMenu;
  43. MenuHandle        gFileMenu;
  44. MenuHandle        gEditMenu;
  45. MenuHandle        gOptionsMenu;
  46. MenuHandle        gSnowMenu;
  47.  
  48. enum
  49. {
  50.     appleMenu = 400, fileMenu, editMenu, optionsMenu, snowMenuColor, snowMenuBW,
  51.     
  52.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  53.     
  54.     newItem = 1, openItem, closeItem, saveItem, saveAsItem, deBinHexItem = 7,
  55.         launchItem=9, forceQuitItem = 11, quitItem,
  56.     
  57.     undoItem = 1, cutItem = 3, copyItem, pasteItem, clearItem, selectAllItem,
  58.     
  59.     boardItem = 1, soundToggle = 3, hideItem = 5,
  60.     
  61.     slowItem=1, mediumItem, fastItem, unused1, redItem, greenItem, blueItem, cyanItem,
  62.         magentaItem, yellowItem, whiteItem, unused2, mutateItem
  63. };
  64.  
  65. /*-----------------------------------------------------------------------------------*/
  66. /* internal stuff for menus.c                                                        */
  67.  
  68. void HandleAppleMenu(short menuItem);
  69. void HandleFileMenu(short menuItem);
  70. void HandleEditMenu(short menuItem);
  71. void HandleHelpMenu(void);
  72. void HandleOptionsMenu(short menuItem);
  73. void HandleSnowMenu(short menuItem);
  74.  
  75. Boolean InitTheMenus(void)
  76. {
  77.     Handle        MBARHandle;
  78.     
  79.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  80.         return FALSE;
  81.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  82.     
  83.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  84.         return FALSE;
  85.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  86.         return FALSE;
  87.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  88.         return FALSE;
  89.     if ((gOptionsMenu=GetMHandle(optionsMenu))==0L)
  90.         return FALSE;
  91.     if (gHasColorQD)
  92.     {
  93.         if ((gSnowMenu=GetMenu(snowMenuColor))==0L)
  94.             return FALSE;
  95.     }
  96.     else
  97.     {
  98.         if ((gSnowMenu=GetMenu(snowMenuBW))==0L)
  99.             return FALSE;
  100.     }
  101.     
  102.     InsertMenu(gSnowMenu, 0);
  103.     
  104.     if (gSystemSevenOrLater)
  105.     {
  106.         AppendMenu(gOptionsMenu, "\p-");
  107.         AppendMenu(gOptionsMenu, "\pHide/1");
  108.     }
  109.     
  110.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  111.     
  112.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  113.     DrawMenuBar();                                /* draws the actual menu bar */
  114.     
  115.     return TRUE;
  116. }
  117.  
  118. void AdjustMenus(void)
  119. {
  120.     WindowPeek    theWindow;
  121.     short            kind;
  122.     
  123.     if (gInProgress)
  124.     {
  125.         DisableItem(gAppleMenu, aboutItem);
  126.         DisableItem(gAppleMenu, aboutMSGItem);
  127.         DisableItem(gAppleMenu, helpPointerItem);
  128.         if (gSystemSevenOrLater)
  129.         {
  130.             DisableItem(gFileMenu, newItem);
  131.             DisableItem(gFileMenu, openItem);
  132.             DisableItem(gFileMenu, closeItem);
  133.             DisableItem(gFileMenu, deBinHexItem);
  134.             DisableItem(gFileMenu, launchItem);
  135.             DisableItem(gFileMenu, quitItem);
  136.         }
  137.         else DisableItem(gFileMenu, 0);
  138.         
  139.         DisableItem(gEditMenu, 0);
  140.         DisableItem(gOptionsMenu, 0);
  141.         DisableItem(gSnowMenu, 0);
  142.     }
  143.     else
  144.     {
  145.         EnableItem(gAppleMenu, aboutItem);
  146.         EnableItem(gAppleMenu, aboutMSGItem);
  147.         EnableItem(gAppleMenu, helpPointerItem);
  148.         if (gSystemSevenOrLater)
  149.         {
  150.             EnableItem(gFileMenu, newItem);
  151.             EnableItem(gFileMenu, openItem);
  152.             EnableItem(gFileMenu, closeItem);
  153.             EnableItem(gFileMenu, deBinHexItem);
  154.             EnableItem(gFileMenu, launchItem);
  155.             EnableItem(gFileMenu, quitItem);
  156.         }
  157.         else EnableItem(gFileMenu, 0);
  158.         EnableItem(gEditMenu, 0);
  159.         EnableItem(gOptionsMenu, 0);
  160.         EnableItem(gSnowMenu, 0);
  161.         
  162.         theWindow = (WindowPeek)FrontWindow();
  163.         kind = theWindow ? theWindow->windowKind : 0;
  164.         
  165.         if (kind < 0)
  166.         {
  167.             EnableItem(gEditMenu, undoItem);
  168.             EnableItem(gEditMenu, cutItem);
  169.             EnableItem(gEditMenu, copyItem);
  170.             EnableItem(gEditMenu, pasteItem);
  171.             EnableItem(gEditMenu, clearItem);
  172.         }
  173.         else
  174.         {
  175.             if ((theWindow!=0L) && ((WindowPtr)theWindow==GetIndWindowGrafPtr(kMainWindow)) &&
  176.                 ((gNumMoves>0) || (gThisJumpString[0]>0x00)))
  177.                 EnableItem(gEditMenu, undoItem);
  178.             else
  179.                 DisableItem(gEditMenu, undoItem);
  180.             DisableItem(gEditMenu, cutItem);
  181.             DisableItem(gEditMenu, copyItem);
  182.             DisableItem(gEditMenu, pasteItem);
  183.             DisableItem(gEditMenu, clearItem);
  184.         }
  185.         
  186.         if(theWindow)
  187.             EnableItem(gFileMenu, closeItem);
  188.         else
  189.             DisableItem(gFileMenu, closeItem);
  190.         
  191.         if (GetIndWindowGrafPtr(kMainWindow))
  192.         {
  193.             DisableItem(gFileMenu, newItem);
  194.             DisableItem(gFileMenu, openItem);
  195.             DisableItem(gOptionsMenu, boardItem);
  196.             EnableItem(gFileMenu, saveItem);
  197.             EnableItem(gFileMenu, saveAsItem);
  198.         }
  199.         else
  200.         {
  201.             EnableItem(gFileMenu, newItem);
  202.             EnableItem(gFileMenu, openItem);
  203.             EnableItem(gOptionsMenu, boardItem);
  204.             DisableItem(gFileMenu, saveItem);
  205.             DisableItem(gFileMenu, saveAsItem);
  206.         }
  207.         
  208.         if (gSystemSevenOrLater)
  209.             EnableItem(gFileMenu, forceQuitItem);
  210.         else
  211.             DisableItem(gFileMenu, forceQuitItem);
  212.         
  213.         if (gSoundAvailable)
  214.             EnableItem(gOptionsMenu, soundToggle);
  215.         else
  216.             DisableItem(gOptionsMenu, soundToggle);
  217.     }
  218.     CheckItem(gOptionsMenu, soundToggle, gSoundToggle&&gSoundAvailable);
  219.     CheckItem(gSnowMenu, slowItem, gSnowSpeed==0x01);
  220.     CheckItem(gSnowMenu, mediumItem, gSnowSpeed==0x02);
  221.     CheckItem(gSnowMenu, fastItem, gSnowSpeed==0x03);
  222.     CheckItem(gSnowMenu, redItem, gSnowColor==0x01);
  223.     CheckItem(gSnowMenu, greenItem, gSnowColor==0x02);
  224.     CheckItem(gSnowMenu, blueItem, gSnowColor==0x03);
  225.     CheckItem(gSnowMenu, cyanItem, gSnowColor==0x04);
  226.     CheckItem(gSnowMenu, magentaItem, gSnowColor==0x05);
  227.     CheckItem(gSnowMenu, yellowItem, gSnowColor==0x06);
  228.     CheckItem(gSnowMenu, whiteItem, gSnowColor==0x07);
  229.     CheckItem(gSnowMenu, mutateItem, gSnowMutates);
  230. }
  231.  
  232. void HandleMenu(long mSelect)
  233. {
  234.     short            menuID = HiWord(mSelect);
  235.     short            menuItem = LoWord(mSelect);
  236.     
  237.     if (menuID==0)
  238.     {
  239.         menuID=HiWord(menuDisable);
  240.         menuItem=LoWord(menuDisable);
  241.         gMenuEnabled=FALSE;
  242.     }
  243.     else gMenuEnabled=TRUE;
  244.     menuDisable=0L;
  245.  
  246.     switch (menuID)
  247.     {
  248.         case appleMenu:
  249.             HandleAppleMenu(menuItem);
  250.             break;
  251.         case fileMenu:
  252.             HandleFileMenu(menuItem);
  253.             break;    
  254.         case editMenu:
  255.             HandleEditMenu(menuItem);
  256.             break;
  257.         case optionsMenu:
  258.             HandleOptionsMenu(menuItem);
  259.             break;
  260.         case snowMenuColor:
  261.         case snowMenuBW:
  262.             HandleSnowMenu(menuItem);
  263.             break;
  264.     }
  265. }
  266.  
  267. void DoTheCloseThing(WindowPeek theWindow)
  268. /* a standard close procedure, called when "close" is chosen from File menu and when
  269.    a window is closed through its close box */
  270. {
  271.     Boolean            gotone;
  272.     short            i;
  273.     short            kind;
  274.     
  275.     if (theWindow==0L)
  276.         return;
  277.     
  278.     kind = theWindow ? theWindow->windowKind : 0;
  279.     if (kind<0)        /* DA window or other system window */
  280.         CloseDeskAcc(kind);
  281.     else
  282.     {
  283.         gotone=FALSE;
  284.         /* see if it's one of ours */
  285.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  286.             gotone=((WindowPtr)theWindow==GetIndWindowGrafPtr(i));
  287.         
  288.         if (gotone)        /* if it's one of ours...  see graphics.c */
  289.             CloseTheIndWindow(i-1);            /* this may return FALSE = not closed */
  290.         else
  291.             DisposeWindow((WindowPtr)theWindow);    /* not one of ours, so just close it */
  292.     
  293.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  294.     }
  295. }
  296.  
  297. void HandleAppleMenu(short menuItem)
  298. {
  299.     GrafPtr        savePort;
  300.     Str255        name;
  301.     
  302.     switch (menuItem)
  303.     {
  304.         case aboutItem:
  305.             if (gMenuEnabled)
  306.                 OpenTheIndWindow(kAbout);
  307.             else DoSound(sound_fluff, TRUE);
  308.             break;
  309.         case aboutMSGItem:
  310.             if (gMenuEnabled)
  311.                 OpenTheIndWindow(kAboutMSG);
  312.             else DoSound(sound_fluff, TRUE);
  313.             break;
  314.         case helpPointerItem:
  315.             if (gMenuEnabled)
  316.                 HandleHelpMenu();
  317.             else DoSound(sound_fluff, TRUE);
  318.             break;
  319.         default:
  320.             if (menuItem > helpPointerItem+1)
  321.             {
  322.                 GetPort(&savePort);
  323.                 GetItem(gAppleMenu, menuItem, name);
  324.                 OpenDeskAcc(name);
  325.                 SetPort(savePort);
  326.             }
  327.             break;
  328.     }
  329. }
  330.  
  331. void HandleFileMenu(short menuItem)
  332. {
  333.     WindowPtr            theWindow;
  334.     short                i;
  335.     Boolean                gotone;
  336.     
  337.     switch (menuItem)
  338.     {
  339.         case newItem:
  340.             if (gMenuEnabled)
  341.                 NewGame();
  342.             else DoSound(sound_fluff, TRUE);
  343.             break;
  344.         case openItem:
  345.             if (gMenuEnabled)
  346.                 LoadSaveDispatch(TRUE, FALSE);
  347.             else DoSound(sound_fluff, TRUE);
  348.             break;
  349.         case closeItem:
  350.             if (gMenuEnabled)
  351.                 DoTheCloseThing((WindowPeek)FrontWindow());
  352.             else DoSound(sound_fluff, TRUE);
  353.             break;
  354.         case saveItem:
  355.             if (gMenuEnabled)
  356.                 LoadSaveDispatch(FALSE, TRUE);
  357.             else DoSound(sound_fluff, TRUE);
  358.             break;
  359.         case saveAsItem:
  360.             if (gMenuEnabled)
  361.                 LoadSaveDispatch(FALSE, FALSE);
  362.             else DoSound(sound_fluff, TRUE);
  363.             break;
  364.         case deBinHexItem:
  365.             if (gMenuEnabled)
  366.             {
  367.                 if (GetSourceFile(&inputFS, TRUE, FALSE))
  368.                     HandleError(DeBinHexDispatch(), FALSE);
  369.             }
  370.             else DoSound(sound_fluff, TRUE);
  371.             break;
  372.         case launchItem:
  373.             if (gMenuEnabled)
  374.             {
  375.                 LaunchDispatch();
  376.             }
  377.             else DoSound(sound_fluff, TRUE);
  378.             break;
  379.         case forceQuitItem:
  380.             if (gMenuEnabled)
  381.                 SysError(0x4e22);
  382.             else DoSound(sound_fluff, TRUE);
  383.             break;
  384.         case quitItem:
  385.             if (gMenuEnabled)
  386.                 gDone = TRUE;
  387.             else DoSound(sound_fluff, TRUE);
  388.             break;
  389.     }
  390. }
  391.  
  392. void HandleEditMenu(short menuItem)
  393. {
  394.     if ((gMenuEnabled) && (menuItem!=2))
  395.     {
  396.         if (gFrontWindowIsOurs)
  397.         {
  398.             switch (menuItem)
  399.             {
  400.                 case undoItem:        CallIndDispatchProc(gFrontWindowIndex, kUndo, 0L);    break;
  401.                 case cutItem:        CallIndDispatchProc(gFrontWindowIndex, kCut, 0L);    break;
  402.                 case copyItem:        CallIndDispatchProc(gFrontWindowIndex, kCopy, 0L);    break;
  403.                 case pasteItem:        CallIndDispatchProc(gFrontWindowIndex, kPaste, 0L);    break;
  404.                 case clearItem:        CallIndDispatchProc(gFrontWindowIndex, kClear, 0L);    break;
  405.                 case selectAllItem:    CallIndDispatchProc(gFrontWindowIndex, kSelectAll, 0L);    break;
  406.             }
  407.         }
  408.         else SystemEdit(menuItem-1);
  409.     }
  410.     else if (menuItem!=2)
  411.         DoSound(sound_fluff, TRUE);
  412. }
  413.  
  414. void HandleOptionsMenu(short menuItem)
  415. {
  416.     switch (menuItem)
  417.     {
  418.         case boardItem:
  419.             if (gMenuEnabled)
  420.                 OpenTheIndWindow(kBoardSize);
  421.             else DoSound(sound_fluff, TRUE);
  422.             break;
  423.         case soundToggle:
  424.             if (gMenuEnabled)
  425.             {
  426.                 gSoundToggle=!gSoundToggle;
  427.                 DoSound(sound_on, TRUE);
  428.             }
  429.             break;
  430.         case hideItem:
  431.             if (gMenuEnabled)
  432.             {
  433.                 MenuKey(0);
  434.             }
  435.             else DoSound(sound_fluff, TRUE);
  436.             break;
  437.     }
  438. }
  439.  
  440. void HandleSnowMenu(short menuItem)
  441. {
  442.     switch (menuItem)
  443.     {
  444.         case slowItem:        gSnowSpeed=0x01;    GetRidOfSnowflake((WindowDataHandle)GetIndWindowDataHandle(kMainWindow));    break;
  445.         case mediumItem:    gSnowSpeed=0x02;    GetRidOfSnowflake((WindowDataHandle)GetIndWindowDataHandle(kMainWindow));    break;
  446.         case fastItem:        gSnowSpeed=0x03;    GetRidOfSnowflake((WindowDataHandle)GetIndWindowDataHandle(kMainWindow));    break;
  447.         case redItem:        gSnowColor=0x01;    break;
  448.         case greenItem:        gSnowColor=0x02;    break;
  449.         case blueItem:        gSnowColor=0x03;    break;
  450.         case cyanItem:        gSnowColor=0x04;    break;
  451.         case magentaItem:    gSnowColor=0x05;    break;
  452.         case yellowItem:    gSnowColor=0x06;    break;
  453.         case whiteItem:        gSnowColor=0x07;    break;
  454.         case mutateItem:    gSnowMutates^=0xFF;    break;
  455.     }
  456. }
  457.  
  458. void HandleHelpMenu(void)
  459. {
  460.     OpenTheIndWindow(kHelp);
  461. }
  462.